﻿#include<iostream>
using namespace std;

//int main()
//{
//	int a = 10;
//	//给a取别名
//	int& b = a;
//	int& c = a;
//	//给别名取别名
//	int& d = c;
//
//	++d;
//
//	cout << a << endl;
//	cout << b << endl;
//	cout << c << endl;
//	cout << d << endl;
//
//	return 0;
//}

//int main()
//{
//	int a = 10;
//	//给a取别名
//	int& b = a;
//
//	int c = 20;
//	b = c;
//
//
//	cout << a << endl;
//	cout << b << endl;
//	cout << c << endl;
//
//	return 0;
//}

//int main()
//{
//	int a = 10;
//	cin >> a;
//	cout << a;
//	return  0;
//}


//void fun(int n = 10)
//{
//	cout << n << endl;
//}
//
//int main()
//{
//	fun();//使用默认值
//	fun(20);//使用实参
//	 
//	return 0;
//}

////全缺省
//void Fun1(int a = 10, int b = 20, int c = 30)
//{
//	cout << a << " " << b << " " << c << endl;
//}
//
////半缺省
//void Fun2(int a, int b = 20, int c = 30)
//{
//	cout << a << " " << b << " " << c << endl;
//}
//
//int main()
//{
//	Fun1();
//	Fun1(1);
//	Fun1(1,2);
//	Fun1(1,2,3);
//	cout << endl;
//	Fun2(1);
//	Fun2(1,2);
//	Fun2(1,2,3);
//
//	return 0;
//}


//#include"Stack.h"
//
//int main()
//{
//	ST s1;
//	STInit(&s1);//初始化默认值
//
//	ST s2;
//	STInit(&s2, 1000);//直接初始化为1000个空间
//
//	return 0;
//}

////参数类型不同
//int Add(int left, int right)
//{
//	cout << "int Add(int left, int right)" << endl;
//	return left + right;
//}
//
//double Add(double left, double right)
//{
//	cout << "double Add(double left, double right)" << endl;
//	return left + right;
//}
//
////参数个数不同
//void Fun()
//{
//	cout << "Fun( ) " << endl;
//}
//
//void Fun(int a)
//{
//	cout << "Fun(int a)" << endl;
//}
//
////参数类型顺序不同
//void Fun(int a, char b)
//{
//	cout << "Fun(int a,char b)" << endl;
//}
//
//void Fun(char b, int a)
//{
//	cout << "Fun(char b,int a)" << endl;
//}

//返回值不同不能作为重载条件，因为调用时无法区分
//void Fun()
//{
//	cout << "Fun( )" << endl;
//}
//
//int Fun(int a)
//{
//	cout << "Fun(int a)" << endl;
//	return a;
//}
//
//int main()
//{
//	Fun();
//	Fun(1);
//	return 0;
//}
// 

//这两个函数构成重载，但是调用Fun()时，两个函数都能匹配，编译器无法确定选择哪一个
//void Fun()
//{
//	cout << " Fun( )" << endl;
//}
//
//void Fun(int a = 10)//缺省值
//{
//	cout << "Fun(int a=10)" << endl;
//}
//
//int main()
//{
//	Fun();
//	Fun(1);
//
//	return 0;
//}

//int main()
//{
//	Add(10, 20);
//	Add(10.1, 20.1);
//
//	Fun();
//	Fun(1);
//	Fun(1,'a');
//	Fun('a', 1);
//	return 0;
//}

//int main()
//{
//	int a = 10;
//	int& b;
//
//	return 0;
//}

//#include<iostream>
//using namespace std;
//
//int main()
//{
//	int a = 10;
//	int b = 20;
//
//	int& c = a;
//	int& c = b;
//
//	return 0;
//}

//int main()
//{
//	int a = 10;
//	int& b = a;
//
//	int c = 20;
//	b = c;//这里是赋值
//
//	cout << a << endl;
//	cout << b << endl;
//	cout << c << endl;
//
//	return 0;
//}

//int main()
//{
//	int a = 10;
//	int& b = a;
//
//	a = 20;
//
//	cout << a << endl;
//	cout << b << endl;
//
//	return 0;
//}

//void Swap(int& rx, int& ry)
//{
//	int tmp = rx;
//	rx = ry;
//	ry = tmp;
//}
//
//int main()
//{
//	int x = 10, y = 20;
//	cout << x << " " << y << endl;
//	
//	Swap(x, y);
//	cout << x << " " << y << endl;
//
//	return 0;
//}

//#include<assert.h>
//
//typedef int SLDataType;
//typedef struct Stack
//{
//	SLDataType* a;
//	int top;
//	int capacity;
//}ST;

//void STInit(ST* ps, int n = 4)
//{
//	assert(ps && n > 0);
//	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * n);
//	ps->top = 0;
//	ps->capacity = n;
//}

//void STInit(ST& rs, int n = 4)
//{
//	rs.a = (SLDataType*)malloc(sizeof(SLDataType) * n);
//	rs.top = 0;
//	rs.capacity = n;
//}

//void STPush(ST* ps, SLDataType x)
//{
//	assert(ps);
//
//	//检查空间
//	if (ps->top == ps->capacity)
//	{
//		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
//		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity*sizeof(SLDataType));
//		if (tmp == NULL)
//		{
//			perror("realloc fail");
//          return;
//		}
//
//		ps->a = tmp;
//		ps->capacity = newcapacity;
//	}
//
//	//插入数据
//	ps->a[ps->top] = x;
//	ps->top++;
//}

//void STPush(ST& rs, SLDataType x)
//{
//	if (rs.top == rs.capacity)
//	{
//		int newcapacity = rs.capacity == 0 ? 4 : rs.capacity * 2;
//		SLDataType* tmp = (SLDataType*)realloc(rs.a, newcapacity * sizeof(SLDataType));
//		if (tmp == NULL)
//		{
//			perror("realloc fail");
//			return;
//		}
//
//		rs.a = tmp;
//		rs.capacity = newcapacity;
//	}
//
//	//插入数据
//	rs.a[rs.top] = x;
//	rs.top++;
//}

//int STTop(ST* ps)
//{
//	assert(ps->top > 0);
//	return ps->a[ps->top - 1];
//}

//int& STTop(ST& rs)
//{
//	assert(rs.top > 0);
//	return rs.a[rs.top - 1];
//}

//int main()
//{
//	ST st1;
//	//STInit(&st1);
//	//STPush(&st1, 1);
//	//STPush(&st1, 2);
//	//cout << STTop(&st1) << endl;
//	STInit(st1);
//	STPush(st1, 1);
//	STPush(st1, 2);
//	cout << STTop(st1) << endl;
//
//	STTop(st1) = 10;//修改栈顶元素
//	cout << STTop(st1) << endl;
//
//	return 0;
//}




//#include<assert.h>
//
//typedef int SLDataType;
//typedef struct Stack
//{
//	SLDataType* a;
//	int top;
//	int capacity;
//}ST;
//
//void STInit(ST* ps, int n = 4)
//{
//	assert(ps && n > 0);
//	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * n);
//	ps->top = 0;
//	ps->capacity = n;
//}
//
//void STPush(ST* ps, SLDataType x)
//{
//	assert(ps);
//
//	//检查空间
//	if (ps->top == ps->capacity)
//	{
//		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
//		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
//		if (tmp == NULL)
//		{
//			perror("realloc fail");
//			return;
//		}
//
//		ps->a = tmp;
//		ps->capacity = newcapacity;
//	}
//
//	//插入数据
//	ps->a[ps->top] = x;
//	ps->top++;
//}
//
//int STTop(ST* ps)
//{
//	assert(ps->top > 0);
//	return ps->a[ps->top - 1];
//}
//
//int main()
//{
//	ST st1;
//	STInit(&st1);
//	STPush(&st1, 1);
//	STPush(&st1, 2);
//	cout << STTop(&st1) << endl;
//
//	return 0;
//}



//typedef struct ListNode
//{
//	int val;
//	struct ListNode* next;
//}LTNode, * PNode;
//
////void ListPushBack(LTNode** phead, int x)
////void ListPushBack(LTNode*& phead, int x)
//// 指针变量也可以取别名，这⾥LTNode*& phead就是给指针变量取别名 
//// 这样就不需要⽤⼆级指针了，相对⽽⾔简化了程序 
//
//void ListPushBack(PNode& phead, int x)
//{
//	PNode newnode = (PNode)malloc(sizeof(LTNode));
//	newnode->val = x;
//	newnode->next = NULL;
//	if (phead == NULL)
//	{
//		phead = newnode;
//	}
//	else
//	{
//		//...
//	}
//}
//
//int main()
//{
//	PNode plist = NULL;
//	ListPushBack(plist, 1);
//	return 0;
//}

//int main()
//{
//	//这里的引用是对a访问权限的放大 
//	const int a = 10;
//	int& ra = a;//err 不能放大权限
//
//	return 0;
//}

//int main()
//{
//	const int a = 10;
//	const int& ra = a;//针对const对象需要用const引用
//
//	return 0;
//}
//
//int main()
//{
//
//	//这里的引用是对a访问权限的缩小
//	int b = 10;
//	const int& rb = b;
//	//rb不可修改，b可以修改
//	b++;
//	rb++;//err
//
//	return 0;
//}

//int main()
//{
//	int a = 10;
//	const int& ra = a;
//
//	//int& rb = a * 3;// err 右边是产生的临时对象具有常性，针对临时对象时需要使用常引用
//	const int& rb = a * 3;
//
//
//	double d = 12.34;
//	//int& rd = d;//err 整型提升 产生的是临时对象，需要使用常引用
//	const int& rd = d;
//
//	return 0;
//}

//int main()
//{
//	int a = 0;
//
//	int* p = &a;
//	*p = 1;
//	
//	int& ra = a;
//	ra = 2;
//
//	return 0;
//}

inline int Add(int x, int y)
{
	int ret = x + y;
	ret += 1;
	return ret;
}

int main()
{
	int ret = Add(1, 2);
	cout << Add(1, 2) * 5 << endl;
	return 0;
}